<!DOCTYPE html>
<html lang="en-US">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>radiometric_self_calibration [HALCON算子参考手册]</title>
<style type="text/css">
      body {
    color: #000000;
    background-color: #ffffff;
    margin: 0;
    font-family: Arial, Helvetica, sans-serif;
}

.body_main {
    margin-left: 35px;
    margin-right: 35px;
}

@media screen and (min-width:992px) {

    .body_main {
        margin-left: 10%;
        margin-right: 10%;
    }

    table.toctable {
        width: 80%
    }
}

@media screen and (min-width:1400px) {

    .body_main {
        margin-left: 15%;
        margin-right: 15%;
    }

    table.toctable {
        width: 70%
    }
}

body>div ul ul {
    margin-left: inherit;
}

a:link {
    color: #0044cc;
}

a:link,
a:visited {
    text-decoration: none;
}

a:link:hover,
a:visited:hover {
    text-decoration: underline;
}

th {
    text-align: left;
}

h1,
h2,
h3,
h4,
h5,
h6 {
    text-rendering: optimizeLegibility;
    color: #666666;
}

code {
    font-family: monospace,monospace;
}

h1 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

h2 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

hr {
    border: 0;
    border-top: solid 1px #f28d26;
}

.pre {
    display: block;
    padding-bottom: 1ex;
    font-family: monospace;
    white-space: pre;
}

pre {
    font-family: monospace, monospace;
    padding: 1ex;
    white-space: pre-wrap;
}

.toc {
    font-size: 80%;
    border-top: 1px dashed #f28d26;
    border-bottom: 1px dashed #f28d26;
    padding-top: 5px;
    padding-bottom: 5px;
}

.inv {
    margin: 0;
    border: 0;
    padding: 0;
}

.banner {
    color: #666666;
    padding-left: 1em;
}

.logo {
    background-color: white;
}

.keyboard {
    font-size: 80%;
    padding-left: 3px;
    padding-right: 3px;
    border-radius: 5px;
    border-width: 1px;
    border-style: solid;
    border-color: #f28d26;
    background-color: #f3f3f3;
}

.warning {
    margin-top: 2ex;
    margin-bottom: 1ex;
    padding: 10px;
    text-align: center;
    border: 1px solid;
    color: #bb0000;
    background-color: #fff7f7
}

.imprint {
    margin-top: 1ex;
    font-size: 80%;
    color: #666666;
}

.imprinthead {
    font-weight: bolder;
    color: #666666;
}

.indexlink {
    text-align: right;
    padding-bottom: 5px;
}

.postscript {
    margin-top: 2ex;
    font-size: 80%;
    color: #666666
}

.evenrow {
    background-color: #e7e7ef;
    vertical-align: top;
}

.oddrow {
    background-color: #f7f7ff;
    vertical-align: top;
}

.headrow {
    background-color: #97979f;
    color: #ffffff;
    vertical-align: top;
}

.logorow {
    vertical-align: top;
}

.error {
    color: red;
}

.var {
    font-style: italic
}

.halconoperator {
    font-family: monospace, monospace;
}

span.operator {
    font-family: monospace, monospace;
}

span.procedure {
    font-family: monospace, monospace;
}

span.operation {
    font-family: monospace, monospace;
}

span.feature {
    font-family: Arial, Helvetica, Homerton, sans-serif;
}

ul {
    padding-left: 1.2em;
}

li.dot {
    list-style-type: square;
    color: #f28d26;
}

.breadcrumb {
    font-size: 80%;
    color: white;
    background-color: #062d64;
    margin-bottom: 20px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 15px;
}

.webbar {
    font-size: 80%;
    background-color: #dddddd;
    margin-top: 0px;
    margin-left: -35px;
    margin-right: -35px;
    margin-bottom: 0px;
    padding-top: 5px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 5px;
}

.footer {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    border-top: 1px dashed #f28d26;
    font-size: 80%;
    color: #666666;
    padding-bottom: 8px;
}

.footer .socialmedia a {
    padding-left: 7px;
}

.socialmedia {
    padding-top: 10px;
}

.copyright {
    margin-top: 19px;
}

.breadcrumb a {
    color: #ffffff;
    border-bottom: 1px solid white;
}

.breadcrumb a:link:hover,
.breadcrumb a:visited:hover {
    text-decoration: none;
    border-bottom: none;
}

.heading {
    margin-top: 1ex;
    font-size: 110%;
    font-weight: bold;
    color: #666666;
}

.text {
    color: black;
}

.example {
    font-size: 80%;
    background-color: #f3f3f3;
    border: 1px dashed #666666;
    padding: 10px;
}

.displaymath {
    display: block;
    text-align: center;
    margin-top: 1ex;
    margin-bottom: 1ex;
}

.title {
    float: left;
    padding-top: 3px;
    padding-bottom: 3px;
}

.signnote {
    font-family: Arial, Helvetica, Homerton, sans-serif;
    font-size: 80%;
    color: #666666;
    font-weight: lighter;
    font-style: italic
}

.par {
    margin-bottom: 1.5em;
}

.parhead {
    text-align: right;
}

.parname {
    float: left;
}

.pardesc {
    font-size: 85%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 2em;
}

.parcat {
    color: #666;
    font-weight: bold;
}

*[data-if=cpp],
*[data-if=c],
*[data-if=dotnet],
*[data-if=com],
*[data-if=python] {
    display: none;
}

.tabbar {
    text-align: right;
    border-bottom: 1px solid #f28d26;
    margin-bottom: 0.5em;
}

ul.tabs {
    padding-top: 3px;
    padding-bottom: 3px;
    margin-top: 10px;
    margin-bottom: 0;
    font-size: 80%
}

ul.tabs li {
    padding-top: 3px;
    padding-bottom: 3px;
    display: inline;
    overflow: hidden;
    list-style-type: none;
    margin: 0;
    margin-left: 8px;
    border-top: 1px solid #666;
    border-left: 1px solid #666;
    border-right: 1px solid #666;
}

ul.tabs li.active {
    border-left: 1px solid #f28d26;
    border-right: 1px solid #f28d26;
    border-top: 1px solid #f28d26;
    border-bottom: 1px solid #fff;
}

ul.tabs li.inactive {
    background-color: #eee;
}

ul.tabs li a {
    padding-left: 5px;
    padding-right: 5px;
    color: #666;
}

ul.tabs li a:link:hover {
    text-decoration: none;
}

ul.tabs li.inactive a {
    color: #666;
}

ul.tabs li.active a {
    color: black;
}

dl.generic dd {
    margin-bottom: 1em;
}

.pari {
    color: olive;
}

.paro {
    color: maroon;
}

.comment {
    font-size: 80%;
    color: green;
    white-space: nowrap;
}

table.grid {
    border-collapse: collapse;
}

table.grid td {
    padding: 5px;
    border: 1px solid;
}

table.layout {
    border: 0px;
}

table.layout td {
    padding: 5px;
}

table.table {
    border-collapse: collapse;
}

table.table td {
    padding: 5px;
    border-left: 0px;
    border-right: 0px;
}

table.table tr:last-child {
    border-bottom: 1px solid;
}

table.table th {
    padding: 5px;
    border-top: 1px solid;
    border-bottom: 1px solid;
    border-left: 0px;
    border-right: 0px;
}

.details_summary {
    cursor: pointer;
}

table.toctable {
    width: 100%;
}

table.toctable col:first-child {
    width: 20%;
}

table.toctable col:nth-last-child(2) {
    width: 8%;
}

table.altcolored tr:nth-child(even) {
    background-color: #f3f3f3;
}

    </style>
<!--OP_REF_STYLE_END-->
<script>
    <!--
var active_lang='hdevelop';function switchVisibility(obj,active_lang,new_lang)
{var display_style='inline';
for(var i=0;i<obj.length;i++)
{if(obj.item(i).getAttribute('data-if')==new_lang)
{obj.item(i).style.display=display_style;}
if(obj.item(i).getAttribute('data-if')==active_lang)
{obj.item(i).style.display='none';}}
return;}
function toggleLanguage(new_lang,initial)
{if(active_lang!=new_lang)
{var lis=document.getElementsByTagName('li');for(var i=0;i<lis.length;i++)
{if(lis.item(i).id=='syn-'+new_lang)
{lis.item(i).className='active';}
else
{lis.item(i).className='inactive';}}
var divs=document.getElementsByTagName('div');var spans=document.getElementsByTagName('span');switchVisibility(divs,active_lang,new_lang);switchVisibility(spans,active_lang,new_lang);if(!initial)
{setCookie("halcon_reference_language",new_lang,null,null);}
active_lang=new_lang;}
return;}
function setCookie(name,value,domain,exp_offset,path,secure)
{localStorage.setItem(name,value);}
function getCookie(name)
{return localStorage.getItem(name);}
function initialize()
{var qs=location.href.split('?')[1];var qs_lang_raw=location.href.split('interface=')[1];var qs_lang;if(qs_lang_raw)
{qs_lang=qs_lang_raw.split('#')[0];}
var cookie_lang=getCookie("halcon_reference_language");var new_lang;if((qs_lang=="hdevelop")||(qs_lang=="dotnet")||(qs_lang=="python")||(qs_lang=="cpp")||(qs_lang=="c"))
{new_lang=qs_lang;setCookie("halcon_reference_language",new_lang,null,null);}
else if((cookie_lang=="hdevelop")||(cookie_lang=="dotnet")||(cookie_lang=="python")||(cookie_lang=="cpp")||(cookie_lang=="c"))
{new_lang=cookie_lang;}
else
{new_lang="hdevelop";}
toggleLanguage(new_lang,1);return;}
-->

  </script>
</head>
<body onload="initialize();">
<div class="breadcrumb">
<br class="inv"><a href="index.html">目录</a> / <a href="toc_calibration.html">Calibration</a> / <a href="toc_calibration_selfcalibration.html">Self-Calibration</a><br class="inv">
</div>
<div class="body_main">
<div class="tabbar"><ul class="tabs">
<li id="syn-hdevelop" class="active"><a href="javascript:void(0);" onclick="toggleLanguage('hdevelop')" onfocus="blur()">HDevelop</a></li>
<li id="syn-dotnet" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('dotnet')" onfocus="blur()">.NET</a></li>
<li id="syn-python" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('python')" onfocus="blur()">Python</a></li>
<li id="syn-cpp" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('cpp')" onfocus="blur()">C++</a></li>
<li id="syn-c" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('c')" onfocus="blur()">C</a></li>
</ul></div>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<!--OP_REF_HEADER_END-->
<h1 id="sec_name">
<span data-if="hdevelop" style="display:inline;">radiometric_self_calibration</span><span data-if="c" style="display:none;">T_radiometric_self_calibration</span><span data-if="cpp" style="display:none;">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none;">RadiometricSelfCalibration</span><span data-if="python" style="display:none;">radiometric_self_calibration</span> (算子名称)</h1>
<h2>名称</h2>
<p><code><span data-if="hdevelop" style="display:inline;">radiometric_self_calibration</span><span data-if="c" style="display:none;">T_radiometric_self_calibration</span><span data-if="cpp" style="display:none;">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none;">RadiometricSelfCalibration</span><span data-if="python" style="display:none;">radiometric_self_calibration</span></code> — Perform a radiometric self-calibration of a camera.</p>
<h2 id="sec_synopsis">参数签名</h2>
<div data-if="hdevelop" style="display:inline;">
<p>
<code><b>radiometric_self_calibration</b>(<a href="#Images"><i>Images</i></a> :  : <a href="#ExposureRatios"><i>ExposureRatios</i></a>, <a href="#Features"><i>特征</i></a>, <a href="#FunctionType"><i>FunctionType</i></a>, <a href="#Smoothness"><i>Smoothness</i></a>, <a href="#PolynomialDegree"><i>PolynomialDegree</i></a> : <a href="#InverseResponse"><i>InverseResponse</i></a>)</code></p>
</div>
<div data-if="c" style="display:none;">
<p>
<code>Herror <b>T_radiometric_self_calibration</b>(const Hobject <a href="#Images"><i>Images</i></a>, const Htuple <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const Htuple <a href="#Features"><i>特征</i></a>, const Htuple <a href="#FunctionType"><i>FunctionType</i></a>, const Htuple <a href="#Smoothness"><i>Smoothness</i></a>, const Htuple <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>, Htuple* <a href="#InverseResponse"><i>InverseResponse</i></a>)</code></p>
</div>
<div data-if="cpp" style="display:none;">
<p>
<code>void <b>RadiometricSelfCalibration</b>(const HObject&amp; <a href="#Images"><i>Images</i></a>, const HTuple&amp; <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const HTuple&amp; <a href="#Features"><i>特征</i></a>, const HTuple&amp; <a href="#FunctionType"><i>FunctionType</i></a>, const HTuple&amp; <a href="#Smoothness"><i>Smoothness</i></a>, const HTuple&amp; <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>, HTuple* <a href="#InverseResponse"><i>InverseResponse</i></a>)</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>::<b>RadiometricSelfCalibration</b>(const HTuple&amp; <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const HString&amp; <a href="#Features"><i>特征</i></a>, const HString&amp; <a href="#FunctionType"><i>FunctionType</i></a>, double <a href="#Smoothness"><i>Smoothness</i></a>, Hlong <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>) const</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>::<b>RadiometricSelfCalibration</b>(double <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const HString&amp; <a href="#Features"><i>特征</i></a>, const HString&amp; <a href="#FunctionType"><i>FunctionType</i></a>, double <a href="#Smoothness"><i>Smoothness</i></a>, Hlong <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>) const</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>::<b>RadiometricSelfCalibration</b>(double <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const char* <a href="#Features"><i>特征</i></a>, const char* <a href="#FunctionType"><i>FunctionType</i></a>, double <a href="#Smoothness"><i>Smoothness</i></a>, Hlong <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>) const</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>::<b>RadiometricSelfCalibration</b>(double <a href="#ExposureRatios"><i>ExposureRatios</i></a>, const wchar_t* <a href="#Features"><i>特征</i></a>, const wchar_t* <a href="#FunctionType"><i>FunctionType</i></a>, double <a href="#Smoothness"><i>Smoothness</i></a>, Hlong <a href="#PolynomialDegree"><i>PolynomialDegree</i></a>) const  <span class="signnote">
            (
            Windows only)
          </span></code></p>
</div>
<div data-if="com" style="display:none;"></div>
<div data-if="dotnet" style="display:none;">
<p>
<code>static void <a href="HOperatorSet.html">HOperatorSet</a>.<b>RadiometricSelfCalibration</b>(<a href="HObject.html">HObject</a> <a href="#Images"><i>images</i></a>, <a href="HTuple.html">HTuple</a> <a href="#ExposureRatios"><i>exposureRatios</i></a>, <a href="HTuple.html">HTuple</a> <a href="#Features"><i>特征</i></a>, <a href="HTuple.html">HTuple</a> <a href="#FunctionType"><i>functionType</i></a>, <a href="HTuple.html">HTuple</a> <a href="#Smoothness"><i>smoothness</i></a>, <a href="HTuple.html">HTuple</a> <a href="#PolynomialDegree"><i>polynomialDegree</i></a>, out <a href="HTuple.html">HTuple</a> <a href="#InverseResponse"><i>inverseResponse</i></a>)</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>.<b>RadiometricSelfCalibration</b>(<a href="HTuple.html">HTuple</a> <a href="#ExposureRatios"><i>exposureRatios</i></a>, string <a href="#Features"><i>特征</i></a>, string <a href="#FunctionType"><i>functionType</i></a>, double <a href="#Smoothness"><i>smoothness</i></a>, int <a href="#PolynomialDegree"><i>polynomialDegree</i></a>)</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HImage.html">HImage</a>.<b>RadiometricSelfCalibration</b>(double <a href="#ExposureRatios"><i>exposureRatios</i></a>, string <a href="#Features"><i>特征</i></a>, string <a href="#FunctionType"><i>functionType</i></a>, double <a href="#Smoothness"><i>smoothness</i></a>, int <a href="#PolynomialDegree"><i>polynomialDegree</i></a>)</code></p>
</div>
<div data-if="python" style="display:none;">
<p>
<code>def <b>radiometric_self_calibration</b>(<a href="#Images"><i>images</i></a>: HObject, <a href="#ExposureRatios"><i>exposure_ratios</i></a>: MaybeSequence[float], <a href="#Features"><i>特征</i></a>: str, <a href="#FunctionType"><i>function_type</i></a>: str, <a href="#Smoothness"><i>smoothness</i></a>: float, <a href="#PolynomialDegree"><i>polynomial_degree</i></a>: int) -&gt; Sequence[Union[int, float]]</code></p>
</div>
<h2 id="sec_description">描述</h2>
<p><code><span data-if="hdevelop" style="display:inline">radiometric_self_calibration</span><span data-if="c" style="display:none">radiometric_self_calibration</span><span data-if="cpp" style="display:none">RadiometricSelfCalibration</span><span data-if="com" style="display:none">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none">RadiometricSelfCalibration</span><span data-if="python" style="display:none">radiometric_self_calibration</span></code> performs a radiometric
self-calibration of a camera.  For this, at least two images that
show the same image contents (scene) must be passed in
<a href="#Images"><i><code><span data-if="hdevelop" style="display:inline">Images</span><span data-if="c" style="display:none">Images</span><span data-if="cpp" style="display:none">Images</span><span data-if="com" style="display:none">Images</span><span data-if="dotnet" style="display:none">images</span><span data-if="python" style="display:none">images</span></code></i></a>.  All images passed in <a href="#Images"><i><code><span data-if="hdevelop" style="display:inline">Images</span><span data-if="c" style="display:none">Images</span><span data-if="cpp" style="display:none">Images</span><span data-if="com" style="display:none">Images</span><span data-if="dotnet" style="display:none">images</span><span data-if="python" style="display:none">images</span></code></i></a> must be
acquired with different exposures.  Typically, the different
exposures are obtained by changing the shutter times at the camera.
It is not recommended to change the exposure by changing the aperture
of the lens since in this case the exposures cannot be determined
accurately enough.  The ratio of the exposures of consecutive images
is passed in <a href="#ExposureRatios"><i><code><span data-if="hdevelop" style="display:inline">ExposureRatios</span><span data-if="c" style="display:none">ExposureRatios</span><span data-if="cpp" style="display:none">ExposureRatios</span><span data-if="com" style="display:none">ExposureRatios</span><span data-if="dotnet" style="display:none">exposureRatios</span><span data-if="python" style="display:none">exposure_ratios</span></code></i></a>.  For example, a value of
<i>0.5</i> specifies that the second image of an image pair has
been acquired with half the exposure of the first image of the pair.
The exposure ratio can easily be determined from the shutter times
since the exposure is proportional to the shutter time.  The
exposure ratio must be greater than 0 and smaller than 1.  This
means that the images must be sorted according to descending
exposure.  <a href="#ExposureRatios"><i><code><span data-if="hdevelop" style="display:inline">ExposureRatios</span><span data-if="c" style="display:none">ExposureRatios</span><span data-if="cpp" style="display:none">ExposureRatios</span><span data-if="com" style="display:none">ExposureRatios</span><span data-if="dotnet" style="display:none">exposureRatios</span><span data-if="python" style="display:none">exposure_ratios</span></code></i></a> must contain one element less
than the number of images passed in <a href="#Images"><i><code><span data-if="hdevelop" style="display:inline">Images</span><span data-if="c" style="display:none">Images</span><span data-if="cpp" style="display:none">Images</span><span data-if="com" style="display:none">Images</span><span data-if="dotnet" style="display:none">images</span><span data-if="python" style="display:none">images</span></code></i></a>.  If all
exposure ratios are identical, as a simplification a single value
can be passed in <a href="#ExposureRatios"><i><code><span data-if="hdevelop" style="display:inline">ExposureRatios</span><span data-if="c" style="display:none">ExposureRatios</span><span data-if="cpp" style="display:none">ExposureRatios</span><span data-if="com" style="display:none">ExposureRatios</span><span data-if="dotnet" style="display:none">exposureRatios</span><span data-if="python" style="display:none">exposure_ratios</span></code></i></a>.
</p>
<p>As described above, the images passed in <a href="#Images"><i><code><span data-if="hdevelop" style="display:inline">Images</span><span data-if="c" style="display:none">Images</span><span data-if="cpp" style="display:none">Images</span><span data-if="com" style="display:none">Images</span><span data-if="dotnet" style="display:none">images</span><span data-if="python" style="display:none">images</span></code></i></a> must show
identical image contents.  Hence, it is typically necessary that
neither the camera nor the objects in the scene move.  If the camera
has rotated around the optical center, the images should be aligned
to a reference image (one of the images) using
<a href="proj_match_points_ransac.html"><code><span data-if="hdevelop" style="display:inline">proj_match_points_ransac</span><span data-if="c" style="display:none">proj_match_points_ransac</span><span data-if="cpp" style="display:none">ProjMatchPointsRansac</span><span data-if="com" style="display:none">ProjMatchPointsRansac</span><span data-if="dotnet" style="display:none">ProjMatchPointsRansac</span><span data-if="python" style="display:none">proj_match_points_ransac</span></code></a> and <a href="projective_trans_image.html"><code><span data-if="hdevelop" style="display:inline">projective_trans_image</span><span data-if="c" style="display:none">projective_trans_image</span><span data-if="cpp" style="display:none">ProjectiveTransImage</span><span data-if="com" style="display:none">ProjectiveTransImage</span><span data-if="dotnet" style="display:none">ProjectiveTransImage</span><span data-if="python" style="display:none">projective_trans_image</span></code></a>.
If the features used for the radiometric calibration are determined
from the 2D gray value histogram of consecutive image pairs
(<a href="#Features"><i><code><span data-if="hdevelop" style="display:inline">特征</span><span data-if="c" style="display:none">特征</span><span data-if="cpp" style="display:none">特征</span><span data-if="com" style="display:none">特征</span><span data-if="dotnet" style="display:none">特征</span><span data-if="python" style="display:none">特征</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'2d_histogram'</span><span data-if="c" style="display:none">"2d_histogram"</span><span data-if="cpp" style="display:none">"2d_histogram"</span><span data-if="com" style="display:none">"2d_histogram"</span><span data-if="dotnet" style="display:none">"2d_histogram"</span><span data-if="python" style="display:none">"2d_histogram"</span></i>), it is essential
that the images are aligned and that the objects in the scene do not
move.  For <a href="#Features"><i><code><span data-if="hdevelop" style="display:inline">特征</span><span data-if="c" style="display:none">特征</span><span data-if="cpp" style="display:none">特征</span><span data-if="com" style="display:none">特征</span><span data-if="dotnet" style="display:none">特征</span><span data-if="python" style="display:none">特征</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'1d_histograms'</span><span data-if="c" style="display:none">"1d_histograms"</span><span data-if="cpp" style="display:none">"1d_histograms"</span><span data-if="com" style="display:none">"1d_histograms"</span><span data-if="dotnet" style="display:none">"1d_histograms"</span><span data-if="python" style="display:none">"1d_histograms"</span></i>, the
features used for the radiometric calibration are determined from
the 1D gray value histograms of the image pairs.  In this mode, the
calibration can theoretically be performed if the 1D histograms of
the images do not change by the movement of the objects in the
images.  This can, for example, be the case if an object moves in
front of a uniformly textured background.  However, it is preferable
to use <a href="#Features"><i><code><span data-if="hdevelop" style="display:inline">特征</span><span data-if="c" style="display:none">特征</span><span data-if="cpp" style="display:none">特征</span><span data-if="com" style="display:none">特征</span><span data-if="dotnet" style="display:none">特征</span><span data-if="python" style="display:none">特征</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'2d_histogram'</span><span data-if="c" style="display:none">"2d_histogram"</span><span data-if="cpp" style="display:none">"2d_histogram"</span><span data-if="com" style="display:none">"2d_histogram"</span><span data-if="dotnet" style="display:none">"2d_histogram"</span><span data-if="python" style="display:none">"2d_histogram"</span></i> because this
mode is more accurate.  The mode <a href="#Features"><i><code><span data-if="hdevelop" style="display:inline">特征</span><span data-if="c" style="display:none">特征</span><span data-if="cpp" style="display:none">特征</span><span data-if="com" style="display:none">特征</span><span data-if="dotnet" style="display:none">特征</span><span data-if="python" style="display:none">特征</span></code></i></a> =
<i><span data-if="hdevelop" style="display:inline">'1d_histograms'</span><span data-if="c" style="display:none">"1d_histograms"</span><span data-if="cpp" style="display:none">"1d_histograms"</span><span data-if="com" style="display:none">"1d_histograms"</span><span data-if="dotnet" style="display:none">"1d_histograms"</span><span data-if="python" style="display:none">"1d_histograms"</span></i> should only be used if it is impossible to
construct the camera set-up such that neither the camera nor the
objects in the scene move.
</p>
<p>Furthermore, care should be taken to cover the range of gray values
without gaps by choosing appropriate image contents.  Whether there
are gaps in the range of gray values can easily be checked based on
the 1D gray value histograms of the images or the 2D gray value
histograms of consecutive images.  In the 1D gray value histograms
(see <a href="gray_histo_abs.html"><code><span data-if="hdevelop" style="display:inline">gray_histo_abs</span><span data-if="c" style="display:none">gray_histo_abs</span><span data-if="cpp" style="display:none">GrayHistoAbs</span><span data-if="com" style="display:none">GrayHistoAbs</span><span data-if="dotnet" style="display:none">GrayHistoAbs</span><span data-if="python" style="display:none">gray_histo_abs</span></code></a>), there should be no areas between the
minimum and maximum gray value that have a frequency of 0 or a very
small frequency.  In the 2D gray value histograms (see
<a href="histo_2dim.html"><code><span data-if="hdevelop" style="display:inline">histo_2dim</span><span data-if="c" style="display:none">histo_2dim</span><span data-if="cpp" style="display:none">Histo2dim</span><span data-if="com" style="display:none">Histo2dim</span><span data-if="dotnet" style="display:none">Histo2dim</span><span data-if="python" style="display:none">histo_2dim</span></code></a>), a single connected region having the shape of a
“strip” should result from a threshold operation with a lower
threshold of 1.  If more than one connected component results, a
more suitable image content should be chosen.  If the image content
can be chosen such that the gray value range of the image (e.g.,
0-255 for byte images) can be covered with two images with different
exposures, and if there are no gaps in the histograms, the two
images suffice for the calibration.  This, however, is typically not
the case, and hence multiple images must be used to cover the entire
gray value range.  As described above, for this multiple images with
different exposures must be taken to cover the entire gray value
range as well as possible.  For this, normally the first image
should be exposed such that the maximum gray value is slightly below
the saturation limit of the camera, or such that the image is
significantly overexposed.  If the first image is overexposed, a
significant overexposure is necessary to enable
<code><span data-if="hdevelop" style="display:inline">radiometric_self_calibration</span><span data-if="c" style="display:none">radiometric_self_calibration</span><span data-if="cpp" style="display:none">RadiometricSelfCalibration</span><span data-if="com" style="display:none">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none">RadiometricSelfCalibration</span><span data-if="python" style="display:none">radiometric_self_calibration</span></code> to detect the overexposed areas
reliably.  If the camera exhibits an unusual saturation behavior
(e.g., a saturation limit that lies significantly below the maximum
gray value) the overexposed areas should be masked out by hand with
<a href="reduce_domain.html"><code><span data-if="hdevelop" style="display:inline">reduce_domain</span><span data-if="c" style="display:none">reduce_domain</span><span data-if="cpp" style="display:none">ReduceDomain</span><span data-if="com" style="display:none">ReduceDomain</span><span data-if="dotnet" style="display:none">ReduceDomain</span><span data-if="python" style="display:none">reduce_domain</span></code></a> in the overexposed image.
</p>
<p><code><span data-if="hdevelop" style="display:inline">radiometric_self_calibration</span><span data-if="c" style="display:none">radiometric_self_calibration</span><span data-if="cpp" style="display:none">RadiometricSelfCalibration</span><span data-if="com" style="display:none">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none">RadiometricSelfCalibration</span><span data-if="python" style="display:none">radiometric_self_calibration</span></code> returns the inverse gray value
response function of the camera in <a href="#InverseResponse"><i><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></i></a>.  The
inverse response function can be used to create an image with a
linear response by using <a href="#InverseResponse"><i><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></i></a> as the LUT in
<a href="lut_trans.html"><code><span data-if="hdevelop" style="display:inline">lut_trans</span><span data-if="c" style="display:none">lut_trans</span><span data-if="cpp" style="display:none">LutTrans</span><span data-if="com" style="display:none">LutTrans</span><span data-if="dotnet" style="display:none">LutTrans</span><span data-if="python" style="display:none">lut_trans</span></code></a>.  The parameter <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> determines
which function model is used to model the response function.  For
<a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'discrete'</span><span data-if="c" style="display:none">"discrete"</span><span data-if="cpp" style="display:none">"discrete"</span><span data-if="com" style="display:none">"discrete"</span><span data-if="dotnet" style="display:none">"discrete"</span><span data-if="python" style="display:none">"discrete"</span></i>, the response function
is described by a discrete function with the relevant number of gray
values (256 for byte images).  For <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> =
<i><span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span></i>, the response is described by a polynomial of
degree <a href="#PolynomialDegree"><i><code><span data-if="hdevelop" style="display:inline">PolynomialDegree</span><span data-if="c" style="display:none">PolynomialDegree</span><span data-if="cpp" style="display:none">PolynomialDegree</span><span data-if="com" style="display:none">PolynomialDegree</span><span data-if="dotnet" style="display:none">polynomialDegree</span><span data-if="python" style="display:none">polynomial_degree</span></code></i></a>.  The computation of the response
function is slower for <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> =
<i><span data-if="hdevelop" style="display:inline">'discrete'</span><span data-if="c" style="display:none">"discrete"</span><span data-if="cpp" style="display:none">"discrete"</span><span data-if="com" style="display:none">"discrete"</span><span data-if="dotnet" style="display:none">"discrete"</span><span data-if="python" style="display:none">"discrete"</span></i>.  However, since a polynomial tends to
oscillate in the areas in which no gray value information can be
derived, even if smoothness constraints are imposed as described
below, the discrete model should usually be preferred over the
polynomial model.
</p>
<p>The inverse response function is returned as a tuple of integer
values for <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'discrete'</span><span data-if="c" style="display:none">"discrete"</span><span data-if="cpp" style="display:none">"discrete"</span><span data-if="com" style="display:none">"discrete"</span><span data-if="dotnet" style="display:none">"discrete"</span><span data-if="python" style="display:none">"discrete"</span></i> and
<a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span></i>.  In some
applications, it might be desirable to return the inverse response
function as floating point values to avoid the numerical error that
is introduced by rounding.  For example, if the inverse response
function must be inverted to obtain the response function of the
camera, there is some loss of information if the values are returned
as integers.  For these applications, <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> can be
set to <i><span data-if="hdevelop" style="display:inline">'discrete_real'</span><span data-if="c" style="display:none">"discrete_real"</span><span data-if="cpp" style="display:none">"discrete_real"</span><span data-if="com" style="display:none">"discrete_real"</span><span data-if="dotnet" style="display:none">"discrete_real"</span><span data-if="python" style="display:none">"discrete_real"</span></i> or <i><span data-if="hdevelop" style="display:inline">'polynomial_real'</span><span data-if="c" style="display:none">"polynomial_real"</span><span data-if="cpp" style="display:none">"polynomial_real"</span><span data-if="com" style="display:none">"polynomial_real"</span><span data-if="dotnet" style="display:none">"polynomial_real"</span><span data-if="python" style="display:none">"polynomial_real"</span></i>, in
which case the inverse response function will be returned as a tuple
of floating point numbers.
</p>
<p>The parameter <a href="#Smoothness"><i><code><span data-if="hdevelop" style="display:inline">Smoothness</span><span data-if="c" style="display:none">Smoothness</span><span data-if="cpp" style="display:none">Smoothness</span><span data-if="com" style="display:none">Smoothness</span><span data-if="dotnet" style="display:none">smoothness</span><span data-if="python" style="display:none">smoothness</span></code></i></a> defines (in addition to the
constraints on the response function that can be derived from the
images) constraints on the smoothness of the response function.  If,
as described above, the gray value range can be covered completely
and without gaps, the default value of <i>1</i> should not be
changed.  Otherwise, values &gt; <i>1</i> can be used to obtain a
stronger smoothing of the response function, while values &lt;
<i>1</i> lead to a weaker smoothing.  The smoothing is
particularly important in areas for which no gray value information
can be derived from the images, i.e., in gaps in the histograms and
for gray values smaller than the minimum gray value of all images or
larger than the maximum gray value of all images.  In these areas,
the smoothness constraints lead to an interpolation or extrapolation
of the response function.  Because of the nature of the internally
derived constraints, <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'discrete'</span><span data-if="c" style="display:none">"discrete"</span><span data-if="cpp" style="display:none">"discrete"</span><span data-if="com" style="display:none">"discrete"</span><span data-if="dotnet" style="display:none">"discrete"</span><span data-if="python" style="display:none">"discrete"</span></i>
favors an exponential function in the undefined areas, whereas
<a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span></i> favors a straight
line.  Please note that the interpolation and extrapolation is
always less reliable than to cover the gray value range completely
and without gaps.  Therefore, in any case it should be attempted
first to acquire the images optimally, before the smoothness
constraints are used to fill in the remaining gaps.  In all cases,
the response function should be checked for plausibility after the
call to <code><span data-if="hdevelop" style="display:inline">radiometric_self_calibration</span><span data-if="c" style="display:none">radiometric_self_calibration</span><span data-if="cpp" style="display:none">RadiometricSelfCalibration</span><span data-if="com" style="display:none">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none">RadiometricSelfCalibration</span><span data-if="python" style="display:none">radiometric_self_calibration</span></code>.  In particular, it
should be checked whether <a href="#InverseResponse"><i><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></i></a> is monotonic.  If
this is not the case, a more suitable scene should be used to avoid
interpolation, or <a href="#Smoothness"><i><code><span data-if="hdevelop" style="display:inline">Smoothness</span><span data-if="c" style="display:none">Smoothness</span><span data-if="cpp" style="display:none">Smoothness</span><span data-if="com" style="display:none">Smoothness</span><span data-if="dotnet" style="display:none">smoothness</span><span data-if="python" style="display:none">smoothness</span></code></i></a> should be set to a larger
value.  For <a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span></i>, it may
also be necessary to change <a href="#PolynomialDegree"><i><code><span data-if="hdevelop" style="display:inline">PolynomialDegree</span><span data-if="c" style="display:none">PolynomialDegree</span><span data-if="cpp" style="display:none">PolynomialDegree</span><span data-if="com" style="display:none">PolynomialDegree</span><span data-if="dotnet" style="display:none">polynomialDegree</span><span data-if="python" style="display:none">polynomial_degree</span></code></i></a>.  If, despite
these changes, an implausible response is returned, the saturation
behavior of the camera should be checked, e.g., based on the 2D gray
value histogram, and the saturated areas should be masked out by
hand, as described above.
</p>
<p>When the inverse gray value response function of the camera is
determined, the absolute energy falling on the camera cannot be
determined.  This means that <a href="#InverseResponse"><i><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></i></a> can only be
determined up to a scale factor.  Therefore, an additional
constraint is used to fix the unknown scale factor: the maximum gray
value that can occur should occur for the maximum input gray value,
e.g., <a href="#InverseResponse"><i><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></i></a>[255] = 255 for byte images.  This
constraint usually leads to the most intuitive results.  If,
however, a multichannel image (typically an RGB image) should be
radiometrically calibrated (for this, each channel must be
calibrated separately), the above constraint may lead to the result
that a different scaling factor is determined for each channel.
This may lead to the result that gray tones no longer appear gray
after the correction.  In this case, a manual white balancing step
must be carried out by identifying a homogeneous gray area in the
original image, and by deriving appropriate scaling factors from the
corrected gray values for two of the three response curves (or, in
general, for n-1 of the n channels).  Here, the response curve
that remains invariant should be chosen such that all scaling
factors are &lt; 1.  With the scaling factors thus determined, new
response functions should be calculated by multiplying each value of
a response function with the scaling factor corresponding to that
response function.</p>
<h2 id="sec_execution">运行信息</h2>
<ul>
  <li>多线程类型:可重入(与非独占操作符并行运行)。</li>
<li>多线程作用域:全局(可以从任何线程调用)。</li>
  <li>未经并行化处理。</li>
</ul>
<h2 id="sec_parameters">参数表</h2>
  <div class="par">
<div class="parhead">
<span id="Images" class="parname"><b><code><span data-if="hdevelop" style="display:inline">Images</span><span data-if="c" style="display:none">Images</span><span data-if="cpp" style="display:none">Images</span><span data-if="com" style="display:none">Images</span><span data-if="dotnet" style="display:none">images</span><span data-if="python" style="display:none">images</span></code></b> (input_object)  </span><span>singlechannelimage-array <code>→</code> <span data-if="hdevelop" style="display:inline">object</span><span data-if="dotnet" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="python" style="display:none">HObject</span><span data-if="cpp" style="display:none"><a href="HImage.html">HImage</a></span><span data-if="c" style="display:none">Hobject</span> (byte / uint2)</span>
</div>
<p class="pardesc">Input images.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="ExposureRatios" class="parname"><b><code><span data-if="hdevelop" style="display:inline">ExposureRatios</span><span data-if="c" style="display:none">ExposureRatios</span><span data-if="cpp" style="display:none">ExposureRatios</span><span data-if="com" style="display:none">ExposureRatios</span><span data-if="dotnet" style="display:none">exposureRatios</span><span data-if="python" style="display:none">exposure_ratios</span></code></b> (input_control)  </span><span>real(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[float]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Ratio of the exposure energies of successive
image pairs.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>0.5</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.25, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>ExposureRatios &gt; 0 &amp;&amp; ExposureRatios &lt; 1</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="Features" class="parname"><b><code><span data-if="hdevelop" style="display:inline">特征</span><span data-if="c" style="display:none">特征</span><span data-if="cpp" style="display:none">特征</span><span data-if="com" style="display:none">特征</span><span data-if="dotnet" style="display:none">特征</span><span data-if="python" style="display:none">特征</span></code></b> (input_control)  </span><span>string <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">str</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Features that are used to compute the inverse
response function of the camera.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'2d_histogram'</span>
    <span data-if="c" style="display:none">"2d_histogram"</span>
    <span data-if="cpp" style="display:none">"2d_histogram"</span>
    <span data-if="com" style="display:none">"2d_histogram"</span>
    <span data-if="dotnet" style="display:none">"2d_histogram"</span>
    <span data-if="python" style="display:none">"2d_histogram"</span>
</p>
<p class="pardesc"><span class="parcat">List of values:
      </span><span data-if="hdevelop" style="display:inline">'1d_histograms'</span><span data-if="c" style="display:none">"1d_histograms"</span><span data-if="cpp" style="display:none">"1d_histograms"</span><span data-if="com" style="display:none">"1d_histograms"</span><span data-if="dotnet" style="display:none">"1d_histograms"</span><span data-if="python" style="display:none">"1d_histograms"</span>, <span data-if="hdevelop" style="display:inline">'2d_histogram'</span><span data-if="c" style="display:none">"2d_histogram"</span><span data-if="cpp" style="display:none">"2d_histogram"</span><span data-if="com" style="display:none">"2d_histogram"</span><span data-if="dotnet" style="display:none">"2d_histogram"</span><span data-if="python" style="display:none">"2d_histogram"</span></p>
</div>
  <div class="par">
<div class="parhead">
<span id="FunctionType" class="parname"><b><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></b> (input_control)  </span><span>string <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">str</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Type of the inverse response function of the
camera.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>
    <span data-if="hdevelop" style="display:inline">'discrete'</span>
    <span data-if="c" style="display:none">"discrete"</span>
    <span data-if="cpp" style="display:none">"discrete"</span>
    <span data-if="com" style="display:none">"discrete"</span>
    <span data-if="dotnet" style="display:none">"discrete"</span>
    <span data-if="python" style="display:none">"discrete"</span>
</p>
<p class="pardesc"><span class="parcat">List of values:
      </span><span data-if="hdevelop" style="display:inline">'discrete'</span><span data-if="c" style="display:none">"discrete"</span><span data-if="cpp" style="display:none">"discrete"</span><span data-if="com" style="display:none">"discrete"</span><span data-if="dotnet" style="display:none">"discrete"</span><span data-if="python" style="display:none">"discrete"</span>, <span data-if="hdevelop" style="display:inline">'discrete_real'</span><span data-if="c" style="display:none">"discrete_real"</span><span data-if="cpp" style="display:none">"discrete_real"</span><span data-if="com" style="display:none">"discrete_real"</span><span data-if="dotnet" style="display:none">"discrete_real"</span><span data-if="python" style="display:none">"discrete_real"</span>, <span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span>, <span data-if="hdevelop" style="display:inline">'polynomial_real'</span><span data-if="c" style="display:none">"polynomial_real"</span><span data-if="cpp" style="display:none">"polynomial_real"</span><span data-if="com" style="display:none">"polynomial_real"</span><span data-if="dotnet" style="display:none">"polynomial_real"</span><span data-if="python" style="display:none">"polynomial_real"</span></p>
</div>
  <div class="par">
<div class="parhead">
<span id="Smoothness" class="parname"><b><code><span data-if="hdevelop" style="display:inline">Smoothness</span><span data-if="c" style="display:none">Smoothness</span><span data-if="cpp" style="display:none">Smoothness</span><span data-if="com" style="display:none">Smoothness</span><span data-if="dotnet" style="display:none">smoothness</span><span data-if="python" style="display:none">smoothness</span></code></b> (input_control)  </span><span>real <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">float</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real)</span><span data-if="dotnet" style="display:none"> (<i>double</i>)</span><span data-if="cpp" style="display:none"> (<i>double</i>)</span><span data-if="c" style="display:none"> (<i>double</i>)</span></span>
</div>
<p class="pardesc">Smoothness of the inverse response function of
the camera.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>1.0</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>0.3, 0.5, 0.7, 0.8, 1.0, 1.2, 1.5, 2.0, 3.0</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>Smoothness &gt; 0</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="PolynomialDegree" class="parname"><b><code><span data-if="hdevelop" style="display:inline">PolynomialDegree</span><span data-if="c" style="display:none">PolynomialDegree</span><span data-if="cpp" style="display:none">PolynomialDegree</span><span data-if="com" style="display:none">PolynomialDegree</span><span data-if="dotnet" style="display:none">polynomialDegree</span><span data-if="python" style="display:none">polynomial_degree</span></code></b> (input_control)  </span><span>integer <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">int</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i>)</span><span data-if="c" style="display:none"> (<i>Hlong</i>)</span></span>
</div>
<p class="pardesc">Degree of the polynomial if
<a href="#FunctionType"><i><code><span data-if="hdevelop" style="display:inline">FunctionType</span><span data-if="c" style="display:none">FunctionType</span><span data-if="cpp" style="display:none">FunctionType</span><span data-if="com" style="display:none">FunctionType</span><span data-if="dotnet" style="display:none">functionType</span><span data-if="python" style="display:none">function_type</span></code></i></a> = <i><span data-if="hdevelop" style="display:inline">'polynomial'</span><span data-if="c" style="display:none">"polynomial"</span><span data-if="cpp" style="display:none">"polynomial"</span><span data-if="com" style="display:none">"polynomial"</span><span data-if="dotnet" style="display:none">"polynomial"</span><span data-if="python" style="display:none">"polynomial"</span></i>.</p>
<p class="pardesc"><span class="parcat">Default:
      </span>5</p>
<p class="pardesc"><span class="parcat">Suggested values:
      </span>1, 2, 3, 4, 5, 6, 7, 8, 9, 10</p>
<p class="pardesc"><span class="parcat">Restriction:
      </span><code>PolynomialDegree &gt;= 1 &amp;&amp; PolynomialDegree &lt;= 20</code></p>
</div>
  <div class="par">
<div class="parhead">
<span id="InverseResponse" class="parname"><b><code><span data-if="hdevelop" style="display:inline">InverseResponse</span><span data-if="c" style="display:none">InverseResponse</span><span data-if="cpp" style="display:none">InverseResponse</span><span data-if="com" style="display:none">InverseResponse</span><span data-if="dotnet" style="display:none">inverseResponse</span><span data-if="python" style="display:none">inverse_response</span></code></b> (output_control)  </span><span>number-array <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">Sequence[Union[int, float]]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (integer / </span><span data-if="hdevelop" style="display:inline">real)</span><span data-if="dotnet" style="display:none"> (<i>int</i> / </span><span data-if="dotnet" style="display:none">long / </span><span data-if="dotnet" style="display:none">double)</span><span data-if="cpp" style="display:none"> (<i>Hlong</i> / </span><span data-if="cpp" style="display:none">double)</span><span data-if="c" style="display:none"> (<i>Hlong</i> / </span><span data-if="c" style="display:none">double)</span></span>
</div>
<p class="pardesc">Inverse response function of the camera.</p>
</div>
<h2 id="sec_example_all">例程 (HDevelop)</h2>
<pre class="example">
open_framegrabber ('1394IIDC', 1, 1, 0, 0, 0, 0, 'default', -1, \
                   'default', -1, 'default', 'default', 'default', \
                   -1, -1, AcqHandle)
* Define appropriate shutter times.
Shutters := [1000,750,500,250,125]
Num := |Shutters|
* Grab and accumulate images with the different exposures.  In this
* loop, it must be ensured that the scene remains static.
gen_empty_obj (Images)
for I := 0 to Num-1 by 1
    set_framegrabber_param (AcqHandle, 'shutter', Shutters[I])
    grab_image (Image, AcqHandle)
    concat_obj (Images, Image, Images)
endfor
* Compute the exposure ratios from the shutter times.
ExposureRatios := real(Shutters[1:Num-1])/real(Shutters[0:Num-2])
radiometric_self_calibration (Images, ExposureRatios, '2d_histogram', \
                              'discrete', 1, 5, InverseResponse)
* Note that if the frame grabber supports hardware LUTs, we could
* also call set_framegrabber_lut here instead of lut_trans below.
* This would be more efficient.
while (1)
    grab_image_async (Image, AcqHandle, -1)
    lut_trans (Image, ImageLinear, InverseResponse)
    * Process radiometrically correct image.
    * [...]
endwhile
close_framegrabber (AcqHandle)
</pre>
<h2 id="sec_result">结果</h2>
<p>如果参数均有效，算子
<code><span data-if="hdevelop" style="display:inline">radiometric_self_calibration</span><span data-if="c" style="display:none">radiometric_self_calibration</span><span data-if="cpp" style="display:none">RadiometricSelfCalibration</span><span data-if="com" style="display:none">RadiometricSelfCalibration</span><span data-if="dotnet" style="display:none">RadiometricSelfCalibration</span><span data-if="python" style="display:none">radiometric_self_calibration</span></code> 返回值 <TT>2</TT> (
      <TT>H_MSG_TRUE</TT>)
    .  If
necessary an exception is raised.</p>
<h2 id="sec_predecessors">可能的前置算子</h2>
<p>
<code><a href="read_image.html"><span data-if="hdevelop" style="display:inline">read_image</span><span data-if="c" style="display:none">read_image</span><span data-if="cpp" style="display:none">ReadImage</span><span data-if="com" style="display:none">ReadImage</span><span data-if="dotnet" style="display:none">ReadImage</span><span data-if="python" style="display:none">read_image</span></a></code>, 
<code><a href="grab_image.html"><span data-if="hdevelop" style="display:inline">grab_image</span><span data-if="c" style="display:none">grab_image</span><span data-if="cpp" style="display:none">GrabImage</span><span data-if="com" style="display:none">GrabImage</span><span data-if="dotnet" style="display:none">GrabImage</span><span data-if="python" style="display:none">grab_image</span></a></code>, 
<code><a href="grab_image_async.html"><span data-if="hdevelop" style="display:inline">grab_image_async</span><span data-if="c" style="display:none">grab_image_async</span><span data-if="cpp" style="display:none">GrabImageAsync</span><span data-if="com" style="display:none">GrabImageAsync</span><span data-if="dotnet" style="display:none">GrabImageAsync</span><span data-if="python" style="display:none">grab_image_async</span></a></code>, 
<code><a href="set_framegrabber_param.html"><span data-if="hdevelop" style="display:inline">set_framegrabber_param</span><span data-if="c" style="display:none">set_framegrabber_param</span><span data-if="cpp" style="display:none">SetFramegrabberParam</span><span data-if="com" style="display:none">SetFramegrabberParam</span><span data-if="dotnet" style="display:none">SetFramegrabberParam</span><span data-if="python" style="display:none">set_framegrabber_param</span></a></code>, 
<code><a href="concat_obj.html"><span data-if="hdevelop" style="display:inline">concat_obj</span><span data-if="c" style="display:none">concat_obj</span><span data-if="cpp" style="display:none">ConcatObj</span><span data-if="com" style="display:none">ConcatObj</span><span data-if="dotnet" style="display:none">ConcatObj</span><span data-if="python" style="display:none">concat_obj</span></a></code>, 
<code><a href="proj_match_points_ransac.html"><span data-if="hdevelop" style="display:inline">proj_match_points_ransac</span><span data-if="c" style="display:none">proj_match_points_ransac</span><span data-if="cpp" style="display:none">ProjMatchPointsRansac</span><span data-if="com" style="display:none">ProjMatchPointsRansac</span><span data-if="dotnet" style="display:none">ProjMatchPointsRansac</span><span data-if="python" style="display:none">proj_match_points_ransac</span></a></code>, 
<code><a href="proj_match_points_ransac_guided.html"><span data-if="hdevelop" style="display:inline">proj_match_points_ransac_guided</span><span data-if="c" style="display:none">proj_match_points_ransac_guided</span><span data-if="cpp" style="display:none">ProjMatchPointsRansacGuided</span><span data-if="com" style="display:none">ProjMatchPointsRansacGuided</span><span data-if="dotnet" style="display:none">ProjMatchPointsRansacGuided</span><span data-if="python" style="display:none">proj_match_points_ransac_guided</span></a></code>, 
<code><a href="projective_trans_image.html"><span data-if="hdevelop" style="display:inline">projective_trans_image</span><span data-if="c" style="display:none">projective_trans_image</span><span data-if="cpp" style="display:none">ProjectiveTransImage</span><span data-if="com" style="display:none">ProjectiveTransImage</span><span data-if="dotnet" style="display:none">ProjectiveTransImage</span><span data-if="python" style="display:none">projective_trans_image</span></a></code>
</p>
<h2 id="sec_successors">可能的后置算子</h2>
<p>
<code><a href="lut_trans.html"><span data-if="hdevelop" style="display:inline">lut_trans</span><span data-if="c" style="display:none">lut_trans</span><span data-if="cpp" style="display:none">LutTrans</span><span data-if="com" style="display:none">LutTrans</span><span data-if="dotnet" style="display:none">LutTrans</span><span data-if="python" style="display:none">lut_trans</span></a></code>
</p>
<h2 id="sec_see">参考其它</h2>
<p>
<code><a href="histo_2dim.html"><span data-if="hdevelop" style="display:inline">histo_2dim</span><span data-if="c" style="display:none">histo_2dim</span><span data-if="cpp" style="display:none">Histo2dim</span><span data-if="com" style="display:none">Histo2dim</span><span data-if="dotnet" style="display:none">Histo2dim</span><span data-if="python" style="display:none">histo_2dim</span></a></code>, 
<code><a href="gray_histo.html"><span data-if="hdevelop" style="display:inline">gray_histo</span><span data-if="c" style="display:none">gray_histo</span><span data-if="cpp" style="display:none">GrayHisto</span><span data-if="com" style="display:none">GrayHisto</span><span data-if="dotnet" style="display:none">GrayHisto</span><span data-if="python" style="display:none">gray_histo</span></a></code>, 
<code><a href="gray_histo_abs.html"><span data-if="hdevelop" style="display:inline">gray_histo_abs</span><span data-if="c" style="display:none">gray_histo_abs</span><span data-if="cpp" style="display:none">GrayHistoAbs</span><span data-if="com" style="display:none">GrayHistoAbs</span><span data-if="dotnet" style="display:none">GrayHistoAbs</span><span data-if="python" style="display:none">gray_histo_abs</span></a></code>, 
<code><a href="reduce_domain.html"><span data-if="hdevelop" style="display:inline">reduce_domain</span><span data-if="c" style="display:none">reduce_domain</span><span data-if="cpp" style="display:none">ReduceDomain</span><span data-if="com" style="display:none">ReduceDomain</span><span data-if="dotnet" style="display:none">ReduceDomain</span><span data-if="python" style="display:none">reduce_domain</span></a></code>
</p>
<h2 id="sec_module">模块</h2>
<p>
Calibration</p>
<!--OP_REF_FOOTER_START-->
<hr>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<div class="footer">
<div class="copyright">HALCON算子参考手册 Copyright © 2015-2023 51Halcon</div>
</div>
</div>
</body>
</html>
